package chapter1.com.sky;


/**
 * @author : wushikai
 * <p>
 * date : 2021-02-23
 */
public class IntegerDemo {


    /**
     * 这篇博客的方法自己体会一波, 跟进源码
     * https://blog.csdn.net/litong09282039/article/details/46309541
     * <p>
     * reference https://www.cnblogs.com/ysocean/p/8564466.html
     */
    public static void test(String[] args) {


        int i = Integer.parseInt("1111", 2);
        System.out.println(i);


        //把 10 进制 转成16 进制数
        String string = Integer.toHexString(512);
        System.out.println(string);

        String string1 = Integer.toBinaryString(-15);
        System.out.println(string1);


        String string2 = Integer.toBinaryString(17);
        System.out.println(string2);


        Integer decode = Integer.decode("123415");
        System.out.println(decode);


        Integer integer = Integer.valueOf("11", 3);
        integer = Integer.valueOf("jkl", 32);  //实际中 进制还有32 进制; 怎么表示是个问题????
        System.out.println(integer);


        //此方法的返回类型为int ，它返回一个整数值，该整数值是通过反转给定整数值的2的补码中的位顺序而生成的
        int reverse = Integer.reverse(1);
        System.out.println(reverse + "    " + Integer.MAX_VALUE);  //-2147483648    2147483647


        //  2的32次方 ==>  4,294,967,296 ;  2的32次方 ==>  2147483648 ;  2 的 31 次方 -1  == >  2147483647


        char han = 0x6c49;
        System.out.println(han);


    }

//封装类
/*
 * 比如int对应的类是Integer
这种类就叫做封装类

 */


    static void m1() {
        // Integer 的构造函数
        Integer it1 = new Integer(5);// 传入的是int类型
        System.out.println(it1);
        Integer it2 = new Integer("88");// 传入的是String类型
        System.out.println(it2);
    }

    static void m2() {
        // 比较两个 int数字值。
        System.out.println(Integer.compare(5, 6));// 左面小于右面，返回一个负数
        System.out.println(Integer.compare(6, 6));// 左面等于右面，返回一个0
        System.out.println(Integer.compare(56, 5));// 左面大于右面，返回一个正数1

        // 数字比较两个 Integer对象。
        Integer i1 = 1;// 要比较的数
        i1.compareTo(8);// 8是参数
        System.out.println(i1.compareTo(8));// 参数大于要比较的数。返回-1
        System.out.println(i1.compareTo(1));// 参数等于要比较的数，等于0
        System.out.println(i1.compareTo(0));// 参数小于要比较的数返回1

        // 比较两个 int值，以数值方式将值视为无符号。
        // 价值0如果x == y ; 如果x < y为无符号值，则小于0 ; 如果x > y为无符号值，则值大于0
        System.out.println(Integer.compareUnsigned(5, 8));
        System.out.println(Integer.compareUnsigned(8, 8));
        System.out.println(Integer.compareUnsigned(8, 5));
    }

    public static void demo(String[] args) {




        // m1();
        // 返回此值 Integer为 byte的基本收缩转换后。也就是说，这个by值必须是Integer类型的
        Integer integer = 3; //自动装箱
        byte by = integer.byteValue();
        // System.out.println(by);

         integer = integer +1; //自动拆箱做运算之后, 再自动装箱;

        //将 String解码成 Integer 。
        Integer llInteger = new Integer(28);
        System.out.println(llInteger.decode("22"));//对象去调用decode方法

//		//返回将第一个参数除以秒的无符号商，其中每个参数和结果被解释为无符号值。
//		System.out.println(Integer.divideUnsigned(8, 2));

        //返回此值 Integer为 double一个宽元转换后。
        Double ddDouble = new Double("55");
        //该对象在转换为 double之后表示的 double
        System.out.println(ddDouble.doubleValue());//所以说doubleVa的使用对象是Double类型

        //equals(Object obj) 将此对象与指定的对象进行比较。
        Integer ll = new Integer(22);
        Integer ql = new Integer(11);
        System.out.println(new Integer(22).equals(new Integer(11)));//返回值为true和false

        //floatValue() 返回此值 Integer为 float一个宽元转换后。
        Float ffFloat = new Float(100.0);
        System.out.println(ffFloat.floatValue());//此对象在转换为 float后转换的 float 。

        //getInteger(String nm) 确定具有指定名称的系统属性的整数值。
        Integer integer2 = new Integer(66);
        //System.out.println(integer2.getInteger("integer2"));

        //getInteger(String nm, int val) 确定具有指定名称的系统属性的整数值。
        //第一个参数被视为系统属性的名称。第二个参数是默认值。 如果没有指定名称的属性，如果该属性没有正确的数字格式，或者指定的名称为空或null ，则返回表示第二个参数的值的Integer对象。
        System.out.println(new Integer(2).getInteger("22", 0));//就等于下面
        System.out.println(new Integer(2).getInteger("22", new Integer(0)));

        //getInteger(String nm, Integer val) 返回具有指定名称的系统属性的整数值。
        System.out.println(new Integer(22).getInteger("", 33));//就等于下面那个
        System.out.println(new Integer(2).getInteger("22", new Integer(0)));

        //hashCode() 返回这个 Integer的哈希码。
        System.out.println(new Integer(56).hashCode());
        //hashCode(int value) 返回值为int的哈希码; 兼容Integer.hashCode() 。
        System.out.println(new Integer("99").hashCode(33));
		/*
		 * 在Java中，哈希码代表了对象的一种特征，例如我们判断某两个字符串是否==，如果其哈希码相等，则这两个字符串是相等的。其次，哈希码是一种数据结构的算法。常见的哈希码的算法有：
			1：Object类的hashCode.返回对象的内存地址经过处理后的结构，由于每个对象的内存地址都不一样，所以哈希码也不一样。
			2：String类的hashCode.根据String类包含的字符串的内容，根据一种特殊算法返回哈希码，只要字符串内容相同，返回的哈希码也相同。
			3：Integer类，返回的哈希码就是Integer对象里所包含的那个整数的数值，例如Integer i1=new Integer(100),i1.hashCode的值就是100 。由此可见，2个一样大小的Integer对象，返回的哈希码也一样。
		 *
		 */

        //highestOneBit(int i)
        //返回一个 int值与至多一个单个1位，在最高阶（“最左侧”）的位置在指定的一个位 int值。
        //这个函数的作用是取 i 这个数的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果。
        Integer ioInteger = 12;

        System.out.println(ioInteger.highestOneBit(13));

        //intValue() 将 Integer的值作为 int 。
        System.out.println(new Integer(9).intValue());//该对象在转换为 int之后表示的 int 。

        //longValue() 返回此值 Integer为 long一个宽元转换后。
        Integer ppInteger = new Integer(56);
        System.out.println(ppInteger.longValue());//该对象在转换为 long之后表示的 long 。

        //max(int a, int b) 返回两个 int的较大值，就像调用 Math.max一样 。
        System.out.println(new Integer(1).max(2, 3));//返回max中最大的值
        //min(int a, int b) 返回两个 int的较小值，就像调用 Math.min一样 。
        System.out.println(new Integer(1).min(2, 3));

        //parseInt(String s) 将字符串参数解析为带符号的十进制整数。默认是十进制
        System.out.println(new Integer(55).parseInt("+110"));
        System.out.println(new Integer(55).parseInt("-110"));//由参数以十进制表示的整数值

        //parseInt(String s, int radix) 将字符串参数解析为第二个参数指定的基数中的有符号整数。
		/*
		 * 方法parseInt(String s,int radix)的目的是输出一个十进制数，这个数字是“String s”但是我们要知道他是多少进制的，而方法中“int radix”参数正是来表达这个信息的。
			比如：parseInt(1010,2)
			意思就是：输出2进制数1010在十进制下的数.
			radix的范围是在2~36之间，超出范围会抛异常。其中s的长度也不能超出7，否则也会抛异常。
		 *
		 */
        System.out.println(new Integer(9).parseInt("111", 11));

        //parseUnsignedInt(String s) 将字符串参数解析为无符号十进制整数。默认是十进制输出
        System.out.println(new Integer(1).parseUnsignedInt("10110"));
        //parseInt(String s, int radix) 将字符串参数解析为第二个参数指定的基数中的有符号整数。
        System.out.println(new Integer(1).parseUnsignedInt("10110", 10));

//		//remainderUnsigned(int dividend, int divisor)
//		//返回无符号余数，将第一个参数除以秒，其中每个参数和结果被解释为无符号值。
//		System.out.println(new Integer(1).remainderUnsigned(200, 300));
//		System.out.println(new Integer(1).remainderUnsigned(20, 30));

//		//vreverse(int i) 返回由指定的二进制补码表示反转位的顺序而获得的值 int值。i - 要反转的值
//		System.out.println(new Integer(10).reverse(3));
//		//reverseBytes(int i) 返回反转指定的二进制补码表示的字节顺序而获得的值 int值。i - 要颠倒其字节的值
//		System.out.println(new Integer(500).reverseBytes(3));

        //shortValue() 返回此值 Integer为 short的基本收缩转换后。
        System.out.println(new Integer(12).shortValue());
        Integer jk = 12;
        //Integer jk1=jk.shortValue();转化后的值的类型为short

        //signum(int i) 返回指定的 int值的 int函数。
        //返回指定的int值的signum函数。 （如果指定的值为负，返回值为-1;如果指定的值为零，返回值为0;如果指定的值为正，返回值为1）。
        System.out.println(new Integer(12).signum(-12));
        System.out.println(new Integer(12).signum(12));
        System.out.println(new Integer(12).signum(0));

        //sum(int a, int b) 根据+运算符将两个整数相加。
        System.out.println(new Integer(0).sum(1, 2));

        //toBinaryString(int i) 在基数2中返回整数参数的字符串表示形式为无符号整数。
        //如果整型变量为负，这个变量加上二百三十二就是实际储存的二进制；如果整型变量为正，这个变量的二进制就是实际存储的二进制．然后，从左到右扫描入字符串中．如果无符号值为零，它就只用一个零来表示；否则的话，无符号字符串第一位不用零来表示．二进制表中只用0和1.
        System.out.println(new Integer(0).toBinaryString(1));
        System.out.println(new Integer(0).toBinaryString(-333));
        System.out.println(new Integer(0).toBinaryString(0));

        //toHexString(int i) 返回整数参数的字符串表示形式，作为16位中的无符号整数。
        //说简单点，就是十进制转化为十六进制
        System.out.println(new Integer(0).toHexString(1));
        System.out.println(new Integer(0).toHexString(-333));
        System.out.println(new Integer(0).toHexString(0));

        //toOctalString(int i) 在基数8中返回整数参数的字符串表示形式为无符号整数。
        //由参数以八进制输出
        System.out.println(new Integer(0).toOctalString(1));
        System.out.println(new Integer(0).toOctalString(-333));
        System.out.println(new Integer(0).toOctalString(0));

        //toString(int i)  返回 String表示此对象 Integer的价值。
        System.out.println(new Integer(0).toString(33));
        System.out.println(new Integer(0).toString(22));

        //toString(int i, int radix) 返回由第二个参数指定的基数中的第一个参数的字符串表示形式。
        System.out.println(new Integer(0).toString(33, 4));//第二个参数是直接基数返回
        System.out.println(new Integer(0).toString(22, 10));

        //toUnsignedLong(int x) 参数给转换 long由无符号转换。
        System.out.println(new Integer(0).toUnsignedLong(22));
        System.out.println(new Integer(0).toUnsignedLong(0));
        System.out.println(new Integer(0).toUnsignedLong(-22));
        //toUnsignedString(int i) 将参数的字符串表示形式返回为无符号十进制值。
        System.out.println(new Integer(1).toUnsignedString(22));
        System.out.println(new Integer(2).toUnsignedString(0));
        System.out.println(new Integer(3).toUnsignedString(-22));
        //toUnsignedString(int i, int radix) 	以第二个参数指定的基数中的无符号整数值返回第一个参数的字符串表示形式。
        System.out.println(new Integer(1).toUnsignedString(22, 2));
        System.out.println(new Integer(2).toUnsignedString(0, 10));
        System.out.println(new Integer(3).toUnsignedString(-22, 8));

        //valueOf(int i) 返回一个 Integer指定的 int值的 Integer实例。
        System.out.println(new Integer(111).valueOf(11));
        System.out.println(new Integer(111).valueOf(-11));
        System.out.println(new Integer(111).valueOf(0));

        //valueOf(String s) 返回一个 Integer对象，保存指定的值为 String 。
        System.out.println(new Integer(111).valueOf("99"));
        System.out.println(new Integer(111).valueOf("88"));
        System.out.println(new Integer(111).valueOf("-12"));

        //valueOf(String s, int radix) 返回一个 Integer对象，保存从指定的String中 String的值，当用第二个参数给出的基数进行解析时。
        //返回第二个参数指定的技术进行解析
        System.out.println(new Integer(111).valueOf("99", 10));
        System.out.println(new Integer(111).valueOf("88", 11));
        System.out.println(new Integer(111).valueOf("-12", 10));


    }


    /**
     * 将整型数字转换为二进制字符串，一共32位，不舍弃前面的0
     * @param number 整型数字
     * @return 二进制字符串
     */
    public  static  String get32BitBinString(int number) {
        StringBuilder sBuilder = new StringBuilder();
        for (int i = 0; i < 32; i++){
            sBuilder.append(number & 1);
            if ((i +1)%4 ==0 ) {
                sBuilder.append(" " );
            }
            number = number >>> 1;
        }
        return sBuilder.reverse().toString();
    }




    public static void main(String[] args){
        String bitBinString = get32BitBinString(2);
        System.out.println(bitBinString);
    }

}
